﻿using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using DynamicAuditor.DTOs;

namespace DynamicAuditor.DALAuditor
{

    /// <summary>
    /// Fecha: 05-Octubre-2010
    /// Autor:Kenneth Bogantes F
    /// Descripcion: En esta clase se va a manejar todas las operaciones correspondientes a PROCESOS COBIT tales como: Insercion, Actualizacion, Eliminacion
    /// y todo lo relaciona con PROCESOS COBIT.
    /// </summary>

   public class clsProcesoCobitMg
   {

       #region conexion

       //Declaracion de la varaiable tipo datacontext que vamos a utilizar en toda la clase.
       DynamicAuditorDataContext bd = new DynamicAuditorDataContext();

       #endregion 

       #region Funciones_Basicas_Mantenimientos

       //--------------------------------------------------------------------------------------------------------------------------

       public int InsertProcesoCobit(DTOs.dtoProcesoCobit procesoCobit)
       {
           //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

           int x = 0;
           PROCESOS_COBIT nuevoRegistro = new PROCESOS_COBIT();

           try
           {

               nuevoRegistro.idProceso = procesoCobit.Idproceso;
               nuevoRegistro.idDominio = procesoCobit.Dominio.Iddominio;
               nuevoRegistro.NombreProceso = procesoCobit.Nombreproceso;
               nuevoRegistro.SiglaProceso = procesoCobit.Siglasproceso;
               nuevoRegistro.Descripcion = procesoCobit.Descripcion;
               nuevoRegistro.Activo = procesoCobit.Activo;
               
               //Se procede a insertar la informacion del proceso cobit
               bd.PROCESOS_COBITs.InsertOnSubmit(nuevoRegistro);
               bd.SubmitChanges();
               x = 1;
           }
           catch (Exception ex)
           {
               throw new Exception("No se pudo insertar el registro. " + ex.Message);

           }
           return x;
       }



       //--------------------------------------------------------------------------------------------------------------------------


       public int UpdateProcesoCobit(DTOs.dtoProcesoCobit procesoCobit)
       {
           //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

           int x = 0;


           try
           {

                PROCESOS_COBIT registro = bd.PROCESOS_COBITs.Single(p => p.idProceso == procesoCobit.Idproceso);

                registro.idProceso = int.Parse ( procesoCobit.Idproceso.ToString());
                registro.idDominio = int.Parse ( procesoCobit.Dominio.Iddominio.ToString ());
                registro.NombreProceso = procesoCobit.Nombreproceso;
                registro.SiglaProceso = procesoCobit.Siglasproceso;
                registro.Descripcion = procesoCobit.Descripcion;
                registro.Activo = bool.Parse ( procesoCobit.Activo.ToString());

            
               bd.SubmitChanges();
               x = 1;
           }
           catch (Exception ex)
           {
               throw new Exception("Ocurrio un error actualizando el registro. " + ex.Message);
           }
           return x;
       }



       //--------------------------------------------------------------------------------------------------------------------------



       public int DeleteProcesoCobit(DTOs.dtoProcesoCobit procesoCobit)
       {
           //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

           int x = 0;

           try
           {

               var registro = bd.PROCESOS_COBITs.Single(p => p.idProceso == procesoCobit.Idproceso);

               bd.PROCESOS_COBITs.DeleteOnSubmit(registro);
               bd.SubmitChanges();
               x = 1;
           }
           catch (Exception ex)
           {
               throw new Exception("No se pudo borrar el registro " + ex.Message);
              
           }

           return x;

       }


       //--------------------------------------------------------------------------------------------------------------------------



       public DTOs.dtoProcesoCobit ObtenerProcesoCobitporId(int idProcesoCobit)
       {
           DTOs.dtoProcesoCobit registro = new DynamicAuditor.DTOs.dtoProcesoCobit();

           try
           {
                PROCESOS_COBIT dato = bd.PROCESOS_COBITs.Single(p => p.idProceso == idProcesoCobit);

                registro.Idproceso = int.Parse(dato.idProceso.ToString());
                registro.Dominio = new clsDominioMg().ObtenerDominioCobitporId(int.Parse(dato.idDominio.ToString()));
                registro.Nombreproceso = dato.NombreProceso;
                registro.Siglasproceso = dato.SiglaProceso;
                registro.Descripcion = dato.Descripcion;
                registro.Activo = bool.Parse( dato.Activo.ToString());

            
           }
           catch (Exception ex)
           {

               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
               return null; 
           }

           return registro;
       }



       //--------------------------------------------------------------------------------------------------------------------------



       public DTOs.dtoProcesoCobit ObtenerProcesoCobitporSiglas(string siglas)
       {
           DTOs.dtoProcesoCobit registro = new DynamicAuditor.DTOs.dtoProcesoCobit();

           try
           {
               PROCESOS_COBIT dato = bd.PROCESOS_COBITs.Single(p => p.SiglaProceso == siglas.Trim());

               registro.Idproceso = int.Parse(dato.idProceso.ToString());
               registro.Dominio = new clsDominioMg().ObtenerDominioCobitporId(int.Parse(dato.idDominio.ToString()));

               registro.Nombreproceso = dato.NombreProceso;
               registro.Siglasproceso = dato.SiglaProceso;
               registro.Descripcion = dato.Descripcion;
               registro.Activo = bool.Parse(dato.Activo.ToString());


           }
           catch (Exception ex)
           {

               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
               return null;
           }

           return registro;
       }


       //--------------------------------------------------------------------------------------------------------------------------




       //--------------------------------------------------------------------------------------------------------------------------



       public List<DTOs.dtoProcesoCobit> ObtenerProcesosCobit(int iddominio)
       {
           int i = 0;
           List<DTOs.dtoProcesoCobit> listaDatos = new List<DTOs.dtoProcesoCobit>();

           try
           {
               var datos = (from p in bd.PROCESOS_COBITs
                            from d in bd.DOMINIOs
                            where p.idDominio == d.idDominio && p.idDominio ==iddominio
                            orderby p.idProceso
                            select new { p, d }

                          );

               foreach (var fila  in datos)
               {
                   listaDatos.Add(new dtoProcesoCobit());

                   listaDatos[i].Idproceso = fila.p.idProceso;
                   listaDatos[i].Dominio = toDTODominioCobit(fila.d);
                   listaDatos[i].Nombreproceso = fila.p.NombreProceso ;
                   listaDatos[i].Descripcion = fila.p.Descripcion ;
                   listaDatos[i].Siglasproceso = fila.p.SiglaProceso;

                   listaDatos[i].Activo = (bool) fila.p.Activo;
                   i++;
               }

           }
           catch (Exception ex)
           {
               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
           }
           return listaDatos;
       }


       //--------------------------------------------------------------------------------------------------------------------------



       public List<DTOs.dtoProcesoCobit> ObtenerProcesosCobitActivos(int iddominio)
       {
           int i = 0;
           List<DTOs.dtoProcesoCobit> listaDatos = new List<DTOs.dtoProcesoCobit>();

           try
           {
               var datos = (from p in bd.PROCESOS_COBITs
                            from d in bd.DOMINIOs
                            where p.idDominio == d.idDominio && p.Activo == true && p.idDominio == iddominio
                            orderby p.idProceso
                            select new { p, d }

                          );

               foreach (var fila in datos)
               {
                   listaDatos.Add(new dtoProcesoCobit());

                   listaDatos[i].Idproceso = fila.p.idProceso;
                   listaDatos[i].Dominio = toDTODominioCobit(fila.d);
                   listaDatos[i].Nombreproceso = fila.p.NombreProceso;
                   listaDatos[i].Descripcion = fila.p.Descripcion;
                   listaDatos[i].Siglasproceso = fila.p.SiglaProceso;

                   listaDatos[i].Activo = (bool)fila.p.Activo;
                   i++;
               }

           }
           catch (Exception ex)
           {
               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
           }
           return listaDatos;
       }


       public List<DTOs.dtoProcesoCobit> ObtenerProcesosUltimaVersionCobit()
       {
           int i = 0;
           List<DTOs.dtoProcesoCobit> listaDatos = new List<DTOs.dtoProcesoCobit>();

           try
           {
               
               var maximo= from ver in bd.VERSION_COBITs
                            group ver by ver.idVersionCobit into g
                            select new { ultimaVersion = g.Max(ver =>ver.idVersionCobit ) };

              
               int idUltimaVersionCobit=0;
               foreach(var m in maximo){
                    idUltimaVersionCobit= m.ultimaVersion;
              
              } 

               var datos = (from p in bd.PROCESOS_COBITs
                            from d in bd.DOMINIOs
                            from v in bd.VERSION_COBITs 
                            where p.idDominio == d.idDominio && d.idVersionCobit== v.idVersionCobit  && p.Activo == true
                            && v.idVersionCobit == idUltimaVersionCobit
                            orderby p.idProceso
                            select new { p, d }

                          );

               foreach (var fila in datos)
               {
                   listaDatos.Add(new dtoProcesoCobit());

                   listaDatos[i].Idproceso = fila.p.idProceso;
                   listaDatos[i].Dominio = toDTODominioCobit(fila.d);
                   listaDatos[i].Nombreproceso = fila.p.NombreProceso;
                   listaDatos[i].Descripcion = fila.p.Descripcion;
                   listaDatos[i].Siglasproceso = fila.p.SiglaProceso;

                   listaDatos[i].Activo = (bool)fila.p.Activo;
                   i++;
               }

           }
           catch (Exception ex)
           {
               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
           }
           return listaDatos;
       }


       //--------------------------------------------------------------------------------------------------------------------------



       public dtoDominios toDTODominioCobit(DOMINIO dominioCobit) {
           dtoDominios nuevo = new dtoDominios();
           nuevo.Iddominio = dominioCobit.idDominio;
           nuevo.Nombredominio = dominioCobit.NombreDominio;
           nuevo.Versioncobit = new clsVersionCobitMg().ObtenerVersionPorId((int)dominioCobit.idVersionCobit);
           nuevo.Activo = (bool)dominioCobit.Activo;
           return nuevo;
       }







       #endregion





   }
}
